#include<bits/stdc++.h>
using namespace std;
int N, M, S, D;
const int maxv = 505;
const int INF = 0x3fffffff;
int G[maxv][maxv];          // 邻接矩阵
int p[maxv];                // 该点的权 即救援队数
int short_path[maxv];       // 最短路径
bool vis[maxv] = { false }; // 是否访问
vector<int> pre[maxv];      // 逆序保存前驱节点
vector<int> tmpPath, path;
int num = 0, optValue = -1;
// Dijkstra
void Dijkstra(int s) {
    // 初始化Dijkstra数组
    fill(short_path, short_path + maxv, INF);
    short_path[s] = 0;
    // 遍历每个点 
    for (int i = 0; i < N; i++) {
        // u表示
        int u = -1, MIN = INF;
        // 遍历其他节点找 最小值
        for (int j = 0; j < N; j++) {
            if (vis[j] == false && short_path[j] < MIN) {
                MIN = short_path[j];
                u = j;
            }
        }
        if (u == -1) return;
        // 标记该点 已访问
        vis[u] = true;
        // 计算 u点 - v点 之间的最短距离
        for (int v = 0; v < N; v++) {
            // 如果u点到v点时，v点没访问过，且u-v是有路径的 进行计算
            if (vis[v] == false && G[u][v] != INF) {
                // 如果前面到u点的距离 加上u-v之间的距离 小于 前面直接到v点的距离 （需要更新 最短路径这个表）  { a, b, c, d }
                if (short_path[u] + G[u][v] < short_path[v]) {
                    short_path[v] = short_path[u] + G[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);  
                } else if (short_path[u] + G[u][v] == short_path[v]) {
                    pre[v].push_back(u);  // { a, b, c, d } -> { a, b, c, d, e }
                }
            }
        }
    }
}
// DFS
void DFS(int v) {
    // DFS 递归结束条件 当从终点递归到起点时
    if (v == S) {
        // 路径数量加一；
        num++;
        tmpPath.push_back(v);
        // 判断是否需要更新路径的总权重 权重更大 需要更新值
        int value = 0;
        for (int i = tmpPath.size() - 1; i >= 0; i--) {
            value += p[tmpPath[i]];
        }
        if (value > optValue) {
            optValue = value;
            path = tmpPath;
        }
        tmpPath.pop_back();
        return;
    }
    tmpPath.push_back(v);
    for (int i = 0; i < pre[v].size(); i++) {
        DFS(pre[v][i]);
    }
    tmpPath.pop_back();
}

int main() {
    cin >> N >> M >> S >> D;
    // fill初始化 邻接矩阵 二维数组
    fill(G[0], G[0] + maxv * maxv, INF); 
    for (int i = 0; i < N; i++) {
        cin >> p[i];
    }
    int u, v, w;
    // 读入数据，完成邻接矩阵的初始化
    for (int i = 0; i < M; i++) {
        cin >> u >> v >> w;
        G[u][v] = G[v][u] = w;
    }
    Dijkstra(S);
    DFS(D);
    // 结果输出
    cout << num << " " << optValue << endl;
    for (int i = path.size() - 1; i >= 0; i--) {
        cout << path[i];
        if (i != 0) cout << " ";
        else cout << endl;
    }
    return 0;
}